using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("TavernBrawlManager")]
	public class TavernBrawlManager : MonoClass
	{
		public static int REGULAR_TAVERN_BRAWL_MINIMUM_CLASS_LEVEL => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "TavernBrawlManager", "REGULAR_TAVERN_BRAWL_MINIMUM_CLASS_LEVEL");

		public static int FSG_BRAWL_MINIMUM_CLASS_LEVEL => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "TavernBrawlManager", "FSG_BRAWL_MINIMUM_CLASS_LEVEL");

		public static int SPECIAL_TAVERN_BRAWL_SEASON_NUMBER_START => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "TavernBrawlManager", "SPECIAL_TAVERN_BRAWL_SEASON_NUMBER_START");

		public static float DEFAULT_REFRESH_SPEC_SLUSH_SECONDS_MIN => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "TavernBrawlManager", "DEFAULT_REFRESH_SPEC_SLUSH_SECONDS_MIN");

		public static float DEFAULT_REFRESH_SPEC_SLUSH_SECONDS_MAX => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "TavernBrawlManager", "DEFAULT_REFRESH_SPEC_SLUSH_SECONDS_MAX");

		public static int REWARD_REFRESH_PADDING_SECONDS => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "TavernBrawlManager", "REWARD_REFRESH_PADDING_SECONDS");

		public static int REWARD_REFRESH_RANDOM_DELAY_MIN => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "TavernBrawlManager", "REWARD_REFRESH_RANDOM_DELAY_MIN");

		public static int REWARD_REFRESH_RANDOM_DELAY_MAX => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "TavernBrawlManager", "REWARD_REFRESH_RANDOM_DELAY_MAX");

		public List<TavernBrawlMission> m_missions => method_3<Class251<TavernBrawlMission>>("m_missions")?.method_25();

		public List<bool> m_downloadableDbfAssetsPendingLoad => method_3<Class250<bool>>("m_downloadableDbfAssetsPendingLoad")?.method_25();

		public BrawlType m_currentBrawlType => method_2<BrawlType>("m_currentBrawlType");

		public bool m_hasGottenClientOptionsAtLeastOnce => method_2<bool>("m_hasGottenClientOptionsAtLeastOnce");

		public bool m_isFirstTimeSeeingThisFeature => method_2<bool>("m_isFirstTimeSeeingThisFeature");

		public bool m_isFirstTimeSeeingCurrentSeason => method_2<bool>("m_isFirstTimeSeeingCurrentSeason");

		public BrawlType CurrentBrawlType => method_11<BrawlType>("get_CurrentBrawlType", Array.Empty<object>());

		public bool IsCurrentBrawlTypeActive => method_11<bool>("get_IsCurrentBrawlTypeActive", Array.Empty<object>());

		public bool CanChallengeToCurrentTavernBrawl => method_11<bool>("get_CanChallengeToCurrentTavernBrawl", Array.Empty<object>());

		public bool HasUnlockedAnyTavernBrawl => method_11<bool>("get_HasUnlockedAnyTavernBrawl", Array.Empty<object>());

		public bool HasUnlockedCurrentTavernBrawl => method_11<bool>("get_HasUnlockedCurrentTavernBrawl", Array.Empty<object>());

		public bool IsFirstTimeSeeingThisFeature => method_11<bool>("get_IsFirstTimeSeeingThisFeature", Array.Empty<object>());

		public bool IsFirstTimeSeeingCurrentSeason => method_11<bool>("get_IsFirstTimeSeeingCurrentSeason", Array.Empty<object>());

		public int LatestSeenTavernBrawlSeason => method_11<int>("get_LatestSeenTavernBrawlSeason", Array.Empty<object>());

		public int LatestSeenTavernBrawlChalkboard => method_11<int>("get_LatestSeenTavernBrawlChalkboard", Array.Empty<object>());

		public bool HasSeenTavernBrawlScreen => method_11<bool>("get_HasSeenTavernBrawlScreen", Array.Empty<object>());

		public long CurrentTavernBrawlSeasonEndInSeconds => method_11<long>("get_CurrentTavernBrawlSeasonEndInSeconds", Array.Empty<object>());

		public long NextTavernBrawlSeasonStartInSeconds => method_11<long>("get_NextTavernBrawlSeasonStartInSeconds", Array.Empty<object>());

		public float CurrentScheduledSecondsToRefresh => method_11<float>("get_CurrentScheduledSecondsToRefresh", Array.Empty<object>());

		public bool IsDeckLocked => method_11<bool>("get_IsDeckLocked", Array.Empty<object>());

		public bool IsCurrentSeasonSessionBased => method_11<bool>("get_IsCurrentSeasonSessionBased", Array.Empty<object>());

		public long CurrentTavernBrawlSeasonNewSessionsClosedInSeconds => method_11<long>("get_CurrentTavernBrawlSeasonNewSessionsClosedInSeconds", Array.Empty<object>());

		public bool IsCurrentTavernBrawlSeasonClosedToPlayer => method_11<bool>("get_IsCurrentTavernBrawlSeasonClosedToPlayer", Array.Empty<object>());

		public bool IsPlayerAtSessionMaxForCurrentTavernBrawl => method_11<bool>("get_IsPlayerAtSessionMaxForCurrentTavernBrawl", Array.Empty<object>());

		public int NumTicketsOwned => method_11<int>("get_NumTicketsOwned", Array.Empty<object>());

		public int NumSessionsAllowedThisSeason => method_11<int>("get_NumSessionsAllowedThisSeason", Array.Empty<object>());

		public int NumSessionsAvailableForPurchase => method_11<int>("get_NumSessionsAvailableForPurchase", Array.Empty<object>());

		public int WinStreak => method_11<int>("get_WinStreak", Array.Empty<object>());

		public int GamesWon => method_11<int>("get_GamesWon", Array.Empty<object>());

		public int GamesLost => method_11<int>("get_GamesLost", Array.Empty<object>());

		public int GamesPlayed => method_11<int>("get_GamesPlayed", Array.Empty<object>());

		public int RewardProgress => method_11<int>("get_RewardProgress", Array.Empty<object>());

		public string EndingTimeText => method_13("get_EndingTimeText");

		public List<TavernBrawlMission> Missions => method_14<Class271<TavernBrawlMission>>("get_Missions", Array.Empty<object>())?.method_25();

		public List<RewardData> CurrentSessionRewards => method_14<Class271<RewardData>>("get_CurrentSessionRewards", Array.Empty<object>())?.method_25();

		public bool IsCurrentBrawlInfoReady => method_11<bool>("get_IsCurrentBrawlInfoReady", Array.Empty<object>());

		public bool IsCurrentBrawlAllDataReady => method_11<bool>("get_IsCurrentBrawlAllDataReady", Array.Empty<object>());

		public bool IsCheated => method_11<bool>("get_IsCheated", Array.Empty<object>());

		public TavernBrawlManager(IntPtr address, string className)
			: base(address, className)
		{
		}

		public TavernBrawlManager(IntPtr address)
			: this(address, "TavernBrawlManager")
		{
		}

		public static bool IsInTavernBrawlFriendlyChallenge()
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "TavernBrawlManager", "IsInTavernBrawlFriendlyChallenge", Array.Empty<object>());
		}

		public static void Init()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "TavernBrawlManager", "Init");
		}

		public static TavernBrawlManager Get()
		{
			return MonoClass.smethod_15<TavernBrawlManager>(TritonHs.MainAssemblyPath, "", "TavernBrawlManager", "Get", Array.Empty<object>());
		}

		public TavernBrawlMission CurrentMission()
		{
			return method_14<TavernBrawlMission>("CurrentMission", Array.Empty<object>());
		}

		public TavernBrawlMission GetMission(BrawlType brawlType)
		{
			return method_14<TavernBrawlMission>("GetMission", new object[1] { brawlType });
		}

		public bool SelectHeroBeforeMission()
		{
			return method_11<bool>("SelectHeroBeforeMission", Array.Empty<object>());
		}

		public string GetStartingTimeText(bool singleLine)
		{
			return method_13("GetStartingTimeText", singleLine);
		}

		public DeckRuleset GetCurrentDeckRuleset()
		{
			return method_14<DeckRuleset>("GetCurrentDeckRuleset", Array.Empty<object>());
		}

		public DeckRuleset GetDeckRuleset(BrawlType brawlType)
		{
			return method_14<DeckRuleset>("GetDeckRuleset", new object[1] { brawlType });
		}

		public void StartGame(long deckId)
		{
			method_8("StartGame", deckId);
		}

		public void StartGameWithHero(int heroCardDbId)
		{
			method_8("StartGameWithHero", heroCardDbId);
		}

		public bool OnFindGameEvent(FindGameEventData eventData, object userData)
		{
			return method_11<bool>("OnFindGameEvent", new object[2] { eventData, userData });
		}

		public void ShowSessionLimitWarning()
		{
			method_8("ShowSessionLimitWarning");
		}

		public bool HasCreatedDeck()
		{
			return method_11<bool>("HasCreatedDeck", Array.Empty<object>());
		}

		public CollectionDeck CurrentDeck()
		{
			return method_14<CollectionDeck>("CurrentDeck", Array.Empty<object>());
		}

		public CollectionDeck GetDeck(BrawlType brawlType)
		{
			return method_14<CollectionDeck>("GetDeck", new object[1] { brawlType });
		}

		public bool HasValidDeckForCurrent()
		{
			return method_11<bool>("HasValidDeckForCurrent", Array.Empty<object>());//bald
			//return this.HasValidDeck(this.m_currentBrawlType, 0);
		}

		public bool HasValidDeck(BrawlType brawlType, int brawlLibraryItemId = 0)//bald
		{
			return method_11<bool>("HasValidDeck", new object[2] { brawlType , brawlLibraryItemId });
		}

		public bool IsSeasonActive(BrawlType brawlType, int seasonId)
		{
			return method_10<bool>("IsSeasonActive", new Class276.Enum20[2]
			{
				Class276.Enum20.ValueType,
				Class276.Enum20.I4
			}, new object[2] { brawlType, seasonId });
		}

		public bool IsScenarioActiveInAnyBrawl(int scenarioId)
		{
			return method_11<bool>("IsScenarioActiveInAnyBrawl", new object[1] { scenarioId });
		}

		public bool IsAllDataReady(BrawlType brawlType)
		{
			return method_11<bool>("IsAllDataReady", new object[1] { brawlType });
		}

		public void RefreshServerData(BrawlType brawlType)
		{
			method_8("RefreshServerData", brawlType);
		}

		public bool HasUnlockedTavernBrawl(BrawlType brawlType)
		{
			return method_11<bool>("HasUnlockedTavernBrawl", new object[1] { brawlType });
		}

		public bool CanChallengeToTavernBrawl(BrawlType brawlType)
		{
			return method_11<bool>("CanChallengeToTavernBrawl", new object[1] { brawlType });
		}

		public bool IsTavernBrawlActive(BrawlType brawlType)
		{
			return method_11<bool>("IsTavernBrawlActive", new object[1] { brawlType });
		}

		public void RefreshPlayerRecord()
		{
			method_8("RefreshPlayerRecord");
		}

		public long TavernBrawlSeasonStartInSeconds(BrawlType brawlType)
		{
			return method_11<long>("TavernBrawlSeasonStartInSeconds", new object[1] { brawlType });
		}

		public float ScheduledSecondsToRefresh(BrawlType brawlType)
		{
			return method_11<float>("ScheduledSecondsToRefresh", new object[1] { brawlType });
		}

		public long TavernBrawlSeasonNewSessionsClosedInSeconds(BrawlType brawlType)
		{
			return method_11<long>("TavernBrawlSeasonNewSessionsClosedInSeconds", new object[1] { brawlType });
		}

		public bool IsSeasonSessionBased(BrawlType brawlType)
		{
			return method_11<bool>("IsSeasonSessionBased", new object[1] { brawlType });
		}

		public void InitImpl()
		{
			method_8("InitImpl");
		}

		public void RegisterOptionsListeners(bool register)
		{
			method_8("RegisterOptionsListeners", register);
		}

		public void NetCache_OnClientOptions()
		{
			method_8("NetCache_OnClientOptions");
		}

		public void NetCache_OnTavernBrawlRecord()
		{
			method_8("NetCache_OnTavernBrawlRecord");
		}

		public void OnOptionChangedCallback(Option option, object prevValue, bool existed, object userData)
		{
			method_8("OnOptionChangedCallback", option, prevValue, existed, userData);
		}

		public bool CheckLatestSeenSeason(bool canSetOption)
		{
			return method_11<bool>("CheckLatestSeenSeason", new object[1] { canSetOption });
		}

		public void CheckLatestSessionLimit(bool seasonHasChanged)
		{
			method_8("CheckLatestSessionLimit", seasonHasChanged);
		}

		public void OnCheckInToFSGResponse()
		{
			method_8("OnCheckInToFSGResponse");
		}

		public void OnFiresideGatheringLeave()
		{
			method_8("OnFiresideGatheringLeave");
		}

		public void ScheduledEndOfCurrentTBCallback(object userData)
		{
			method_8("ScheduledEndOfCurrentTBCallback", userData);
		}

		public void ScheduledEndOfCurrentTBCallback_AfterSpreadWhenRewardsExpected(object userData)
		{
			method_8("ScheduledEndOfCurrentTBCallback_AfterSpreadWhenRewardsExpected", userData);
		}

		public void ScheduledRefreshTBSpecCallback(object userData)
		{
			method_8("ScheduledRefreshTBSpecCallback", userData);
		}

		public void ScheduleTBClosedUpdateCallback(object userData)
		{
			method_8("ScheduleTBClosedUpdateCallback", userData);
		}

		public long TavernBrawlSeasonEndInSeconds(BrawlType brawlType)
		{
			return method_11<long>("TavernBrawlSeasonEndInSeconds", new object[1] { brawlType });
		}

		public void OnBeginSession()
		{
			method_8("OnBeginSession");
		}

		public void OnRetireSession()
		{
			method_8("OnRetireSession");
		}

		public void OnAckRewards()
		{
			method_8("OnAckRewards");
		}

		public void OnTavernBrawlRecord()
		{
			method_8("OnTavernBrawlRecord");
		}

		public void OnTavernBrawlInfo()
		{
			method_8("OnTavernBrawlInfo");
		}

		public void Cheat_SetScenario(int scenarioId, BrawlType brawlType)
		{
			method_8("Cheat_SetScenario", scenarioId, brawlType);
		}

		public void Cheat_ResetToServerData()
		{
			method_8("Cheat_ResetToServerData");
		}

		public void Cheat_ResetSeenStuff(int newValue)
		{
			method_8("Cheat_ResetSeenStuff", newValue);
		}

		public void Cheat_SetWins(int numWins)
		{
			method_8("Cheat_SetWins", numWins);
		}

		public void Cheat_SetLosses(int numLosses)
		{
			method_8("Cheat_SetLosses", numLosses);
		}

		public void Cheat_SetActiveSession(int status)
		{
			method_8("Cheat_SetActiveSession", status);
		}

		public void Cheat_DoHeroicRewards(int wins)
		{
			method_8("Cheat_DoHeroicRewards", wins);
		}
	}
}
